Comment créer un type d'opération programmée supplémentaire

EMu fournit trois fonctions d’Opérations programmées par défaut :

Cette section explique comment créer un type supplémentaire d'Opération programmée :

Lors de la planification d'une opération dans un enregistrement dans le module Opérations programmées, l'opération peut être programmée pour commencer :

A un moment spécifié
-OU-
Immédiatement

Si Commencer : (Exécution) est défini sur Immédiatement, l'opération sera appelée dès que l'enregistrement Opérations programmées sera sauvegardé. L'opération commencera à s'exécuter sur le serveur EMu et le contrôle sera rendu à l'utilisateur pour qu'il continue son travail.

Si Commencer : (Exécution) est réglé sur À un moment spécifié, l'opération sera invoquée par le script emuoperations sur le serveur EMu en temps voulu.

Note: L'exécution de chaque opération en attente consomme une licence de la même manière qu'un utilisateur consommerait une licence pour effectuer la tâche. Comme pour les utilisateurs effectuant des tâches, plusieurs opérations peuvent être exécutées simultanément jusqu'à la limite de licence du système.

Le script emuoperations est conçu pour être exécuté à partir de cron avec une entrée similaire à la suivante :

30 17 * * * /home/ke/emu/client/bin/emurun emuoperations 2>&1 | /home/ke/emu/client/bin/emurun emulogger -t "KE EMu Operations" -z operations

Le script est typiquement exécuté une fois par jour, mais peut être configuré pour s’exécuter un nombre illimité de fois pendant la journée. Lorsque le script emuoperations s'exécute, il cherche les opérations qui étaient planifiées pour être exécutées avant la date et heure actuelles et les lance.

Note: La date et l’heure spécifiées dans un enregistrement Opérations programmées correspondent au moment le plus tôt auquel l’opération sera exécutée. L'heure réelle à laquelle une opération est exécutée dépend de l'heure à laquelle le script emuoperations est programmé : emuoperations est le script utilisé pour exécuter une opération programmée dans un enregistrement du module Opérations planifiées. Lorsque emuoperations s'exécute, il cherche les opérations planifiées pour être exécutées avant la date et heure actuelles et les lance. Ainsi, si emuoperations est programmé pour s'exécuter une fois par jour, il commencera toute opération planifiée pour s'exécuter dans les 24 heures précédentes : en théorie, une opération pourrait avoir été planifiée pour s'exécuter 23 heures et 59 minutes plus tôt. Si emuoperations doit être exécuté une fois par jour, il est probablement judicieux de programmer des opérations proches de l'heure d’exécution de emuoperations. Il est également possible d'exécuter emuoperations à différents moments de la journée.

emuoperations ré-exécutera également toutes les opérations précédentes qui n'ont pas abouties.

Accéder à l'information à partir d'un enregistrement Opérations programmées

Chaque type d’Opération programmée enregistre une fonction qui est appelée pour traiter l'opération. Par exemple, l’Opération programmée Supprimer (Delete) est effectuée par une fonction enregistrée appelée Delete.

sub

Register

my $plugins = shift;

#  We handle the "Delete" method.

$plugins->{"Delete"} = \&Delete;

La fonction est passée deux paramètres :

Une session IMu qui permet d'accéder aux enregistrements EMu pour effectuer l'opération.
Un hachage des données à partir d'un enregistrement Opérations programmées avec les détails sur cette opération particulière (c.-à-d. quand, quels enregistrements sont affectés, quel module, etc.).

sub

Delete

my $imusession = shift;

my $record = shift;

#  Run the "Delete" operation.

...

La liste des clés disponibles dans le hachage sont :

`Irn`	L’IRN (NEI) d'un enregistrement dans le module Opérations programmées avec les détails sur cette opération programmée.
`Name`	Le nom de l'opération.
`Type`	Le type d'opération.
`Module`	Le module sur lequel l’opération doit être effectuée.
`ActionIrn`	L’IRN cible pour l'opération Fusionner.
`IrnsToProcess`	La liste des IRN que l'opération doit traiter.
`IrnsProcessed`	La liste des IRN que l'opération a déjà traités. Note: Généralement, ce sera une liste vide, sauf si une opération a échoué.
`Directory`	Le répertoire qui contient les fichiers / informations requis par une opération pour le traitement.
`Identifier`	Un identificateur à ajouter aux enregistrements mis à jour dans le cadre de l'exécution de l'opération.

Les valeurs des clés sont accessibles via le paramètre $record par exemple :

$record->{Module}

-OU-

@{$record->{IrnsToProcess}}

Un exemple d’opération

Dans cet exemple, une liste d’IRN (NEI) est supprimée :

#!/usr/bin/perl

use strict;

use warnings;

use lib "$ENV{EMUPATH}/utils/imu/lib";

use IMu::Module;

#  Registration function.

no warnings 'redefine';

sub

Register

my $plugins = shift;

#  We handle the "Delete" method.

$plugins->{"Delete"} = \&Delete;

use warnings 'redefine';

#  The handler for the "Delete" operation

sub

Delete

my ($imusession, $record) = @_;

my ($attachments, $start, @deleteirns, $irn, $i);

# Check that we have the required information

if (! defined($record->{IrnsToProcess}) || @{$record->{IrnsToProcess}} == 0)

FileLog("Error: no irns supplied for deletion");

return(1);

elsif (! defined($record->{Module}) or $record->{Module} eq "")

FileLog("Error: delete module is not defined");

return(1);

# Get the other information that we need to process

$attachments = GetAttachmentFields($record->{Module});

@deleteirns = @{$record->{IrnsToProcess}};

$start = GetStartPosition($record);

FileLog("Running DELETE plugin for $record->{Module}");

FileLog("%d records scheduled for deletion, starting at position $start", scalar(@deleteirns));

# Now delete each record in turn

for ($i = $start; $i < @deleteirns; $i++)

$irn = $deleteirns[$i];

FileLog("Deleting irn $irn...");

last if (! ProcessDeletion($imusession, $attachments, $irn, $record));

AddToProcessed($irn);

return($i != @deleteirns);

# Do the actual deletion work

sub

ProcessDeletion

my ($imusession, $attachments, $irn, $record) = @_;

my ($table, $colname, $module, @matches, $hits, %found, $key, $column);

eval

%found = ();

foreach $key (keys %{$attachments})

# The assignment here is unusual but it gets around an

# odd foreach scoping problem after an exception is thrown.

$table = $key;

$module = IMu::Module->new($table, $imusession);

foreach $column (keys %{$attachments->{$table}})

# Find records that match this irn

$colname = $column;

$hits = $module->findTerms([$colname, $irn]);

next if ($hits <= 0);

# Add records to found hash

FileLog("Found $hits matches for $colname in $table");

push(@{$found{$table}->{$colname}}, GetMatches($module));

};

if ($@)

FileLog("Error: failed to process $colname in $table for irn $irn: $@");

return(0);

@matches = keys %found;

if (@matches)

# Log that we cannot delete the record

FileLog("Unable to delete irn $irn because it is attached in the following places:");

foreach $table (@matches)

foreach $colname (keys %{$found{$table}})

FileLog("\tModule: $table, Column: $colname, Record(s): " . join(", ", @{$found{$table}->{$colname}}));

else

# Delete the record

DeleteRecord($imusession, $irn, $record);

# Add irn to processed

return(1);

# Delete the record

sub

DeleteRecord

my ($imusession, $irn, $record) = @_;

my ($module, $hits, $result);

eval

$module = IMu::Module->new($record->{Module}, $imusession);

$hits = $module->findKey($irn);

if ($hits > 0)

$result = $module->remove("start", 0, 1);

if ($result == 0)

FileLog("Failed to delete irn $irn from $record->{Module}");

else

FileLog("Failed to find irn $irn in $record->{Module}");

};

if ($@)

FileLog("Failed to delete $irn from $record->{Module}: $@");

# Get all the records that match the attachment query

sub

GetMatches

my ($module) = @_;

my ($result, @matches, $row);

# Get all of the records at once

@matches = ();

$result = $module->fetch("start", 0, -1, "irn");

if ($result->{count})

# Get the irn for each row and push it to the list of matches

foreach $row (@{$result->{rows}})

push(@matches, $row->{irn});

return(@matches);

1;